/**
 * Created by mar105 on 2019-02-13.
 */
import moment from 'moment';
import React, { Component } from 'react';
import reactComponentDebounce from 'react-component-debounce';
import { Form, InputNumber, Checkbox, DatePicker, Input, Cascader, Select, AutoComplete } from 'antd';
import * as commonUtils from '../../utils/utils';
import styles from '../../index.less';
import Provinces from '../../assets/provinces.json';
import Cities from '../../assets/cities.json';
import Areas from '../../assets/areas.json';

const FormItem = Form.Item;
const { Option } = Select;
const { TextArea } = Input;
const InputNumberA = reactComponentDebounce(500)(InputNumber);
const { RangePicker } = DatePicker;

export default class CommonComponent extends Component {
  /**   构造函数   */
  constructor(props) {
    super(props);
    this.state = {
      dataValue: props.dataValue, /*   本showType数据 */
      enabled: props.enabled, /*   是否是查看状态(数据格式:布尔)   */
      dropDownData: [], /*   下拉数据集(如果不是下拉控件该值为空,数据格式:数组对象)   */
      isDropDownLoadFinish: !(props.showConfig.sDropDownType === 'sql' || props.showConfig.sDropDownType === 'const'), /*   下拉数据加载是否完成(下拉初始值是false,其它的都是true)   */
      bReGetDropDown: false, //  是否重新获取下拉数据
      sFieldName: props.showConfig.sName, // 字段名
      bNotEmpty: props.showConfig.bNotEmpty,
    };
    this.firstDataIndex = props.showConfig.sName.substring(0, 1); /*   控件首字母(数据格式:字符串)   */
    this.max = commonUtils.convertStrToNumber(props.showConfig.sMaxValue); /*   最大值(数据格式:数字)   */
    this.min = commonUtils.convertStrToNumber(props.showConfig.sMinValue); /*   最小值(数据格式:数字)   */
    this.getFieldDecorator = commonUtils.isUndefined(props.form) ? undefined : props.form.getFieldDecorator; /*   字段验证(数据格式:数字)   */
    this.floatNum = this.props.getFloatNum(props.showConfig.sName); /*   数字格式化规范转换(数据格式:数字)   */
    this.floatPrice = this.getFloatPrice(this.floatNum); /*   价格格式化规范转换(数据格式:数字)   */
    this.formItemLayout = commonUtils.isNotEmptyObject(props.formItemLayout) ?
      props.formItemLayout :
      { labelCol: { span: 7 }, wrapperCol: { span: 15 } }; /*   表格样式(主要是colspan和rowspan,数据格式:对象)   */
  }

  /**   渲染前只执行一次   */
  componentWillMount() {
    /*   如果是下拉控件,则要获取数据   */
    if ((this.props.showConfig.sDropDownType === 'sql' || this.props.showConfig.sDropDownType === 'const')
      && (this.firstDataIndex === 'i' || this.firstDataIndex === 'd' || this.firstDataIndex === 's')) {
      this.getDropDownData();
    }
  }

  /**   props改变的时候触发   */
  componentWillReceiveProps(nextProps) {
    /*   如果是下拉控件,则要获取数据(获取下拉数据前要先更新sqlCondition)   */
    const {
      dataValue, enabled, dropDownData, sFieldName, bNotEmpty,
    } = this.state;
    if ((this.props.showConfig.sDropDownType === 'sql') && (this.firstDataIndex === 'i' || this.firstDataIndex === 'd' || this.firstDataIndex === 's')) {
      const newDropDownData = commonUtils.getStoreDropDownData(this.props.formId, this.props.name, this.props.showConfig.sName);
      if (!nextProps.showConfig.bReGetDropDown && nextProps.showConfig.dropDownData !== undefined && JSON.stringify(newDropDownData) !== JSON.stringify(nextProps.showConfig.dropDownData)) {
        this.setState({
          dropDownData: nextProps.showConfig.dropDownData,
        });
      } else if (JSON.stringify(newDropDownData) !== JSON.stringify(dropDownData) || nextProps.showConfig.bReGetDropDown) {
        if (commonUtils.isEmptyArr(newDropDownData)) {
          this.getDropDownData();
        }
        this.setState({
          dropDownData: newDropDownData,
        });
      }
    }
    /*   把需要更新的数据setState   */
    if (dataValue !== nextProps.dataValue || enabled !== nextProps.enabled || bNotEmpty !== nextProps.showConfig.bNotEmpty || sFieldName !== nextProps.showConfig.sName) {
      if (this.props.showConfig.bSum && enabled) {
        this.props.handleSum(this.props.showConfig.sName);
      }
      this.firstDataIndex = nextProps.showConfig.sName.substring(0, 1); /*   控件首字母(数据格式:字符串)   */
      this.setState({
        dataValue: nextProps.dataValue,
        enabled: nextProps.enabled,
        sFieldName: nextProps.showConfig.sName,
        bNotEmpty: nextProps.showConfig.bNotEmpty,
      });
    }
  }

  shouldComponentUpdate(nextProps, nextState) {
    const {
      dataValue, isDropDownLoadFinish, enabled, dropDownData, sFieldName, bNotEmpty,
    } = this.state;
    return dataValue !== nextState.dataValue || isDropDownLoadFinish !== nextState.isDropDownLoadFinish || enabled !== nextState.enabled ||
      sFieldName !== nextState.sFieldName || bNotEmpty !== nextState.bNotEmpty || JSON.stringify(dropDownData) !== JSON.stringify(nextState.dropDownData);
  }

  /**   下拉时看是否要重新获取数据   */
  onDropdownVisibleChange = (open) => {
    const { bReGetDropDown } = this.state;
    if (open && bReGetDropDown) {
      this.setState({ isDropDownLoadFinish: false });
      this.getDropDownData(bReGetDropDown);
    }
  }
  /**   获取selectprops对象   */
  getSelectProps = () => {
    /*   返回值声明   */
    const obj = {
      showSearch: true, /*   是否有查找功能   */
      disabled: !this.state.enabled /*   修改的时候传过来的数据   */
        || !this.state.isDropDownLoadFinish, /*   下拉是否完成   */
      onChange: this.handleSelectOptionEvent, /*   选择触发事件   */
      filterOption: this.filterOption, /*  搜索时过滤对应的 option 属性  */
      onDropdownVisibleChange: this.onDropdownVisibleChange,
      placeholder: this.placeholder || '请选择', /* 下拉选择提示 */
    };
    /*   主表时才赋值value   */
    if (this.props.bTable) {
      obj.value = this.state.dataValue; /*   数据值   */
      obj.className = styles.editSelect;
    }
    /*   返回值   */
    return obj;
  };

  /**   获取optionValue对象   */
  getOptionValues = (data) => {
    /*   返回值声明   */
    let res = '';
    /*   计数器   */
    let count = 1;
    /*   遍历每一条数据   */
    const iVisCount = this.props.showConfig.iVisCount === 0 ? 1 : this.props.showConfig.iVisCount;
    if (commonUtils.isNotEmptyStr(this.props.showConfig.sVisColumnName)) {
      res = data[this.props.showConfig.sVisColumnName];
    } else {
      for (const key of Object.keys(data)) {
        /*   这里主要是为了实现配置中控制下拉的展现列数   */
        if (count <= iVisCount && key !== 'sId') {
          if (res === '') {
            res = data[key];
          } else {
            res = res.concat('-').concat(data[key]);
          }
          count += 1;
        }
      }
    }
    /*   返回值   */
    return res;
  };

  /**   获取innerinput控件   */
  getInnerInput = (innerInputProps) => {
    console.log('innnerInputProps' );
    console.log(innerInputProps);
    console.log(this.firstDataIndex);
    if ((this.props.showConfig.sDropDownType === 'sql' || this.props.showConfig.sDropDownType === 'const')
      && (this.firstDataIndex === 'i' || this.firstDataIndex === 'd' || this.firstDataIndex === 's')) { /*   下拉选择框(数字和文本选择框才会下拉)   */
      if (this.props.showConfig.bCanInput) { /*   文本输入下拉框   */
        return <AutoComplete {...this.getSelectProps()} >{this.getSelectOption()}</AutoComplete>;
      } else { /*   普通下拉框   */
        return <Select {...this.getSelectProps()} >{this.getSelectOption()}</Select>;
      }
    } else if (this.firstDataIndex === 'i' || this.firstDataIndex === 'd') { /*   数字输入框(整形i和浮点型d)   */
      return <InputNumberA placeholder={0} {...innerInputProps} style={{ background: '#FAFAFA' }} />;
    } else if (this.firstDataIndex === 'b') { /*   选择框(布尔类型b)   */
      return <Checkbox {...innerInputProps} >{this.showName}</Checkbox>;
    } else if (this.firstDataIndex === 't') { /*   时间选择框(时间类型t)   */
      return <DatePicker placeholder={innerInputProps.placeholder || '请选择时间'} {...innerInputProps} style={{ background: '#FAFAFA' }} />;
    } else if (this.firstDataIndex === 'p') { /*   时间选择框(时间类型t)   */
      return <RangePicker style={{ background: '#FAFAFA' }} {...innerInputProps} />;
    } else if (this.firstDataIndex === 's') { /*   文本输入框(文本s)   */
      if (this.props.textArea) { /*   大文本输入框   */
        return <TextArea placeholder={innerInputProps.placeholder || '请填写'} {...innerInputProps} style={{ background: '#FAFAFA' }} />;
      } else { /*   普通文本输入框   */
        return <Input placeholder={innerInputProps.placeholder || '请填写'} {...innerInputProps} style={{ background: '#FAFAFA' }} />;
      }
    } else if (this.firstDataIndex === 'c') { /*   地址联动框(联动下拉类型c)   */
      return <Cascader {...innerInputProps} />;
    } else { /*   文本输入框(默认类型)   */
      return <Input {...innerInputProps} />;
    }
  };
  /**   获取selectOption对象   */
  getSelectOption = () => {
    /*   返回值声明   */
    const options = [];
    /*   执行条件   */
    if (commonUtils.isNotEmptyArr(this.state.dropDownData)) {
      /*   遍历下拉数据   */
      for (const each of this.state.dropDownData) {
        /*   拼接optoin对象   */
        const option = <Option key={each.sId} value={each.sId}>{this.getOptionValues(each)}</Option>;
        /*   返回值赋值   */
        options.push(option);
      }
    }

    /*   下拉空处理   */
    if (this.props.showConfig.bFirstEmpty) {
      options.push(<Option key=" ">--</Option>);
    }
    /*   下拉新增处理   */
    if (this.props.showConfig.bNewRecord) {
      options.unshift(<Option key="000">NEW RECORD</Option>);
    }
    /*   返回值   */
    return options;
  };

  /*   获取sqlCondition对象   */
  getFloatPrice = (floatNum) => {
    /*   返回值声明   */
    let floatPrice = '';
    /*   返回值赋值   */
    if (commonUtils.isUndefined(floatNum)) {
      for (let i = 0; i < floatNum; i += 1) {
        floatPrice += '\\d';
      }
    }
    /*   返回值   */
    return floatPrice;
  };

  /**   获取下拉值   */
  getDropDownData = async (bReGetDropDown) => {
    /**   下拉类型区分
     1、判断是否直接传下拉，如果传了就直接用,并存储到store中去
     2、没有传看 getStoreDropDownData有没有存储，存储后直接取用
     3、 没有存储时直接调用后台SQL语句去下拉 */
    if (this.props.showConfig.sDropDownType === 'sql') { /*   数据下拉   */
      let { dropDownData } = this.props.showConfig;
      if (commonUtils.isEmptyArr(dropDownData)) {
        dropDownData = commonUtils.getStoreDropDownData(this.props.formId, this.props.name, this.props.showConfig.sName);
        if (commonUtils.isEmptyArr(dropDownData) || bReGetDropDown) {
          dropDownData = await this.props.getSqlDropDownData(this.props.formId, this.props.name, this.props.showConfig);
        }
      } else {
        commonUtils.setStoreDropDownData(this.props.formId, this.props.name, this.props.showConfig.sName, dropDownData);
      }
      this.setState({
        dropDownData,
        isDropDownLoadFinish: true,
        bReGetDropDown: false,
      });
    } else if (this.props.showConfig.sDropDownType === 'const') { /*   常量下拉   */
      /*   常量下拉其实只取一次数据就可以啦,去过数据的会给state中的dropDownData赋值,所以dropDownData有值的情况就不需要再获取了   */
      if (commonUtils.isEmptyArr(this.state.dropDownData)) {
        const { showDropDown } = this.props.showConfig;
        /*   把常量下拉对象转换成数组格式来适配(最终state中dropDownData的值都是数组对象的形式)   */
        const dropDownContainer = commonUtils.objectToArr(commonUtils.convertStrToObj(showDropDown));
        /*   给state赋值   */
        this.setState({
          dropDownData: dropDownContainer,
          isDropDownLoadFinish: true,
        });
      }
    }
  };

  /**   获取innerinput控件参数   */
  getInnerInputProps = () => {
    /*   主表和从表的innerinputprops对象有区别   */
    if (!this.props.bTable) { /*   主表   */
      return this.getInnerInputPropsMaster();
    } else { /*   主从表   */
      return this.getInnerInputPropsSlave();
    }
  };

  /**   获取innerinput控件参数(从)   */
  getInnerInputPropsSlave = () => {
    /*   返回值声明   */
    let obj = {};
    if (this.firstDataIndex === 'i' || this.firstDataIndex === 'd') { /*   数字输入框(整形i和浮点型d)   */
      obj = this.getNumberInnerInputPropsSlave();
    } else if (this.firstDataIndex === 'b') { /*   选择框(布尔类型b)   */
      obj = this.getBooleanInnerInputPropsSlave();
    } else if (this.firstDataIndex === 't' || this.firstDataIndex === 'p') { /*   时间选择框(时间类型t)   */
      obj = this.getDateInnerInputPropsSlave();
    } else if (this.firstDataIndex === 's') { /*   文本输入框(文本s)   */
      obj = this.getTextInnerInputPropsSlave();
    } else if (this.firstDataIndex === 'c') { /*   地址联动框(联动下拉类型c)   */
      obj = this.getAddressInnerInputPropsSlave();
    }
    /*   返回值   */
    return obj;
  };

  /*   获取地址innerinputprops对象(从)   */
  getAddressInnerInputPropsSlave = () => {
    /*   返回值   */
    const obj = {
      disabled: !this.state.enabled, /*   是否可编辑   */
      placeholder: '请选择省市区', /*   预期值的提示信息   */
      options: this.getProvinceCityAreaData(), /*   数据   */
      changeOnSelect: true, /*   对每个选择值进行更改   */
      onChange: this.handleSelectOptionEvent, /*   数据改变回带到父组件   */
      value: commonUtils.isUndefined(this.state.dataValue) ? [] : typeof this.state.dataValue === 'string' ?
        this.state.dataValue.split(',') : commonUtils.convertUndefinedToEmptyArr(this.state.dataValue), /*   数据值   */
    };
    /*   返回值   */
    return obj;
  };

  /*   获取文本innerinputprops对象(从)   */
  getTextInnerInputPropsSlave = () => {
    /*   返回值声明   */
    const obj = {
      disabled: !this.state.enabled, /*   是否可编辑   */
      onChange: e => this.handleSelectOptionEvent(e.target.value), /*   数据改变回带到父组件   */
      value: commonUtils.isUndefined(this.state.dataValue) ? '' : commonUtils.strUndefinedToEmpty(this.state.dataValue), /*   数据值   */
      placeholder: this.placeholder || '请填写', /* 填写提示 */
    };
    /*   最大值最小值   */
    if (typeof this.max === 'number') {
      obj.maxLength = this.max; /*   最大长度   */
    }
    /*   返回值   */
    return obj;
  };

  /*   获取日期innerinputprops对象(从)   */
  getDateInnerInputPropsSlave = () => {
    /*   返回值声明   */
    const obj = {
      disabled: !this.state.enabled, /*   是否可编辑   */
      onChange: this.handleSelectOptionEvent, /*   数据改变回带到父组件   */
      format: this.props.getDateFormat(), /*   格式化规则   */
      disabledDate: this.getDataMaxAndMin, /*   不可选日期   */
    };
    /*   值填充   */
    obj.value = commonUtils.isUndefined(this.state.dataValue) ? null : moment(this.state.dataValue);
    /*   返回值   */
    return obj;
  };

  /*   获取布尔innerinputprops对象(从)   */
  getBooleanInnerInputPropsSlave = () => {
    /*   返回值声明   */
    const obj = {
      disabled: !this.state.enabled, /*   是否可编辑   */
      onChange: this.handleSelectOptionEvent, /*   数据改变回带到父组件   */
      checked: commonUtils.isUndefined(this.state.dataValue) ? false : commonUtils.converNumStrToBoolean(this.state.dataValue), /*   是否选中   */
    };
    /*   返回值   */
    return obj;
  };

  /*   获取数字innerinputprops对象(从)   */
  getNumberInnerInputPropsSlave = () => {
    /*   返回值声明   */
    const obj = {
      className: styles.inputNum, /*   样式名称   */
      disabled: !this.state.enabled, /*   是否可编辑   */
      onChange: value => this.handleSelectOptionEvent(commonUtils.convertStrToNumber0(value)), /*   数据改变回带到父组件   */
    };
    /*   最大值最小值   */
    if (typeof this.max === 'number') {
      obj.max = this.max; /*   最大值   */
    }
    if (typeof this.min === 'number') {
      obj.min = this.max; /*   最小值   */
    }
    /*   浮点型需要格式化   */
    if (this.firstDataIndex === 'd') {
      obj.precision = this.floatNum;
      obj.formatter = value => this.limitDecimals(value);
      obj.parser = value => this.limitDecimals(value);
    }
    /*   值填充   */
    obj.value = this.state.dataValue;
    /*   返回值   */
    return obj;
  };

  /**   获取innerinput控件参数(主)   */
  getInnerInputPropsMaster = () => {
    /*   返回值声明   */
    let obj = {};
    if (this.firstDataIndex === 'i' || this.firstDataIndex === 'd') { /*   数字输入框(整形i和浮点型d)   */
      obj = this.getNumberInnerInputPropsMaster();
    } else if (this.firstDataIndex === 'b') { /*   选择框(布尔类型b)   */
      obj = this.getBooleanInnerInputPropsMaster();
    } else if (this.firstDataIndex === 't' || this.firstDataIndex === 'p') { /*   时间选择框(时间类型t)   */
      obj = this.getDateInnerInputPropsMaster();
    } else if (this.firstDataIndex === 's') { /*   文本输入框(文本s)   */
      if (this.props.textArea) { /*   大文本输入框   */
        obj = this.getTextAreaInnerInputPropsMaster();
      } else { /*   普通文本输入框   */
        obj = this.getTextInnerInputPropsMaster();
      }
    } else if (this.firstDataIndex === 'c') { /*   地址联动框(联动下拉类型c)   */
      obj = this.getAddressInnerInputPropsMaster();
    }
    /*   返回值   */
    return obj;
  };

  /*   获取地址innerinputprops对象(主)   */
  getAddressInnerInputPropsMaster = () => {
    return {
      disabled: !this.state.enabled, /*   是否可编辑   */
      placeholder: '请选择省市区', /*   预期值的提示信息   */
      options: this.getProvinceCityAreaData(), /*   数据   */
      changeOnSelect: true, /*   对每个选择值进行更改   */
      onChange: this.handleSelectOptionEvent, /*   数据改变回带到父组件   */
    };
  };

  /*   获取文本innerinputprops对象(主)   */
  getTextInnerInputPropsMaster = () => {
    /*   返回值声明   */
    const obj = {
      disabled: !this.state.enabled, /*   是否可编辑   */
      onChange: e => this.handleSelectOptionEvent(e.target.value), /*   数据改变回带到父组件   */
    };
    /*   最大值最小值   */
    if (typeof this.max === 'number') {
      obj.maxLength = this.max; /*   最大长度   */
    }
    /*   返回值   */
    return obj;
  };

  /*   获取大文本innerinputprops对象(主)   */
  getTextAreaInnerInputPropsMaster = () => {
    /*   返回值声明   */
    const obj = {
      disabled: !this.state.enabled, /*   是否可编辑   */
      rows: 4, /*   纵跨度   */
      onChange: this.handleSelectOptionEvent, /*   数据改变回带到父组件   */
    };
    /*   最大值最小值   */
    if (typeof this.max === 'number') {
      obj.maxLength = this.max; /*   最大长度   */
    }
    return obj;
  };

  /*   获取日期最大值和最小值   */
  getDataMaxAndMin = (current) => {
    return this.getDataMax(current) || this.getDataMin(current);
  }

  /*   获取日期最大值   */
  getDataMax = (current) => {
    return commonUtils.isNotEmptyStr(this.max) && current.endOf('day') > moment(this.max).endOf('day');
  }

  /*   获取日期最小值   */
  getDataMin = (current) => {
    return commonUtils.isNotEmptyStr(this.min) && current.endOf('day') < moment(this.min).endOf('day');
  }

  /*   获取时间innerinputprops对象(主)   */
  getDateInnerInputPropsMaster = () => {
    return {
      disabled: !this.state.enabled, /*   是否可编辑   */
      style: { width: 'auto', display: 'block' }, /*   样式   */
      format: this.props.getDateFormat(), /*   格式化规则   */
      onChange: this.handleSelectOptionEvent, /*   数据改变回带到父组件   */
      disabledDate: this.getDataMaxAndMin, /*   不可选日期   */
    };
  };

  /*   获取布尔innerinputprops对象(主)   */
  getBooleanInnerInputPropsMaster = () => {
    return {
      disabled: !this.state.enabled, /*   是否显示   */
      onChange: this.handleSelectOptionEvent, /*   数据改变回带到父组件   */
      checked: commonUtils.isUndefined(this.state.dataValue) ? false : commonUtils.converNumStrToBoolean(this.state.dataValue), /*   是否选中   */
    };
  };

  /*   获取数字innerinputprops对象(主)   */
  getNumberInnerInputPropsMaster = () => {
    /*   如果是浮点型并且有格式规定,display类型需要变为block   */
    let display = 'inline-block';
    if (this.firstDataIndex === 'd' && this.floatNum !== 0) {
      display = 'block';
    }
    /*   返回值赋值   */
    const obj = {
      style: { width: 'auto', display, marginRight: 0 }, /*   样式   */
      disabled: !this.state.enabled, /*   是否显示   */
      onChange: this.handleSelectOptionEvent, /*   数据改变回带到父组件   */
    };
    /*   最大值最小值   */
    if (typeof this.max === 'number') {
      obj.max = this.max; /*   最大值   */
    }
    if (typeof this.min === 'number') {
      obj.min = this.max; /*   最小值   */
    }
    /*   格式规格不为0就在props里设置一下   */
    if (this.firstDataIndex === 'd' && this.floatNum !== 0) {
      obj.precision = this.floatNum;
    }
    /*   返回值   */
    return obj;
  };

  /*   获取省市区数据   */
  getProvinceCityAreaData = () => {
    /*   返回值声明   */
    const options = [];
    /*   获取省数据   */
    this.getProvinceData(options);
    /*   获取市数据   */
    this.getCityData(options);
    /*   获取区数据   */
    this.getAreaData(options);
    /*   返回值   */
    return options;
  };

  /*   获取省数据   */
  getProvinceData = (options) => {
    Provinces.forEach((childProvince) => {
      options.push({
        value: childProvince.name, /*   文字   */
        label: childProvince.name, /*   标签   */
        code: childProvince.code, /*   编码   */
        children: [], /*   子节点(city)   */
      });
    });
  };

  /*   获取市数据   */
  getCityData = (options) => {
    options.forEach((childProvince) => {
      const cities = Cities.filter(item => item.provinceCode === childProvince.code);
      if (cities.length > 0) {
        cities.forEach((childCity) => {
          childProvince.children.push({
            value: childCity.name, /*   文字   */
            label: childCity.name, /*   标签   */
            code: childCity.code, /*   编码   */
            children: [], /*   子节点(area)   */
          });
        });
      }
    });
  };

  /*   获取区数据   */
  getAreaData = (options) => {
    options.forEach((childProvince) => {
      const cities = childProvince.children;
      cities.forEach((childCity) => {
        const areas = Areas.filter((item => item.cityCode === childCity.code));
        if (areas.length > 0) {
          areas.forEach((area) => {
            childCity.children.push({
              value: area.name, /*   文字   */
              label: area.name, /*   标签   */
              code: area.code, /*   编码   */
            });
          });
        }
      });
    });
  };

  /*   获取formitemprops对象   */
  getOutFormItemProps = () => {
    /*   主表和从表的formitemprops对象有区别   */
    if (!this.props.bTable) { /*   主表   */
      return this.getOutFormItemPropsMaster();
    } else { /*   从表   */
      return this.getOutFormItemPropsSlave();
    }
  };

  /*   获取formitemprops对象(主)   */
  getOutFormItemPropsMaster = () => {
    /*   返回值声明   */
    let obj = {};
    if (this.firstDataIndex === 'i'
      || this.firstDataIndex === 'd'
      || this.firstDataIndex === 't'
      || this.firstDataIndex === 'p'
      || this.firstDataIndex === 's'
      || this.firstDataIndex === 'c') { /*   数字输入框(整形i和浮点型d),
     时间选择框(时间类型t),
     文本输入框(文本s),
     地址联动框(联动下拉类型c)   */
      obj = {
        label: this.props.showConfig.showName, /*   标签   */
        className: styles.formItemMargin, /*   样式名称   */
        ...this.formItemLayout, /*   主要是rowspan和colspan   */
      };
    } else if (this.firstDataIndex === 'b') { /*   选择框(布尔类型b)   */
      obj = {
        label: this.props.showConfig.showName, /*   标签   */
        className: styles.formItemMag10, /*   样式名称   */
        ...this.formItemLayout, /*   主要是rowspan和colspan   */
      };
    }
    /*   返回值   */
    return obj;
  };

  /*   获取formitemprops对象(从)   */
  getOutFormItemPropsSlave = () => {
    /*   返回值声明   */
    let obj = {};
    if (this.firstDataIndex === 'i'
      || this.firstDataIndex === 'd'
      || this.firstDataIndex === 'c'
      || this.props.showConfig.sDropDownType === 'sql'
      || this.props.showConfig.sDropDownType === 'const') { /*   数字输入框(整形i和浮点型d),
     时间选择框(时间类型t),
     文本输入框(文本s),
     地址联动框(联动下拉类型c),
     所有的下拉(从表只有文字下拉,分常量和sql两种)   */
      obj = {
        className: styles.formItemMargin0, /*   样式名称   */
      };
    } else if (this.firstDataIndex === 'b') { /*   选择框(布尔类型b)   */
      obj = {
        className: styles.tableCheckBox, /*   样式名称   */
      };
    } else if (this.firstDataIndex === 't' || this.firstDataIndex === 'p') { /*   时间选择框(时间类型t)   */
      obj = {
        className: styles.tableDataPicker, /*   样式名称   */
      };
    } else if (this.firstDataIndex === 's') { /*   文本输入框(文本s)   */
      obj = {
        className: styles.editInput, /*   样式名称   */
      };
    }
    /*   返回值   */
    return obj;
  };


  /*   获取fielddecoratorprops对象   */
  getFieldDecoratorProps = () => {
    /*   返回值声明   */
    let obj = {};
    if (this.firstDataIndex === 'i' || this.firstDataIndex === 'd' || this.firstDataIndex === 't' || this.firstDataIndex === 'p' || this.firstDataIndex === 's' || this.firstDataIndex === 'b') { /*   数字输入框(整形i和浮点型d),时间选择框(时间类型t),文本输入框(文本s),选择框(布尔类型b)   */
      obj = { rules: [{ required: this.props.showConfig.bNotEmpty, message: `${this.props.showConfig.showName}为必填项` }] };
    } else if (this.firstDataIndex === 'c') { /*   地址联动框(联动下拉类型c)   */
      obj = {
        initialValue: ['北京市', '市辖区', '东城区'], /*   默认值   */
        rules: [{ required: this.props.showConfig.bNotEmpty, message: `${this.props.showConfig.showName}为必填项` }], /*   规则   */
      };
    }
    /*   返回值   */
    return obj;
  };
  /**   处理下拉选择事件   */
  handleSelectOptionEvent = (value) => {
    /*   下拉新增单独处理   */
    if (this.props.showConfig.sDropDownType === 'sql' && value === '000') {
      this.props.handleSqlDropDownNewRecord(this.props.showConfig);
      this.setState({ bReGetDropDown: true });
      return;
    }
    /*   回带值声明   */
    const returnValue = {};

    /*   回带值赋值(sName:value)   */
    returnValue[this.props.showConfig.sName] =
      this.firstDataIndex === 's' && this.props.textArea ? value.target.value : this.firstDataIndex === 'b' ? value.target.checked : value;

    const { sAssignField } = this.props.showConfig;
    const [changeData] = this.state.dropDownData.filter(item => item.sId === value);
    if (!commonUtils.isEmpty(sAssignField)) {
      /* 赋值数组 */
      const sAssignFieldObj = sAssignField.split(',');
      if (commonUtils.isNotEmptyObject(changeData)) {
        for (const child of sAssignFieldObj) {
          if (child.indexOf(':') > -1) {
            const sFieldName = child.split(':')[0].trim();
            const sValueName = child.split(':')[1].trim();
            returnValue[sFieldName] = changeData[sValueName];
          }
        }
      }
    }
    /*   调用父组件的回带函数   */
    this.props.onChange(this.props.name, this.props.showConfig.sName, returnValue, this.props.sId, this.state.dropDownData);
  };

  /**  搜索时过滤对应的 option 属性 */
  filterOption = (input, option) => {
    return option.props.children.toLowerCase().indexOf(input.toLowerCase()) >= 0;
  };


  // noinspection JSAnnotator
  // limitDecimals = (value) => {
  //   return commonUtils.filterDisNumberN(value, this.floatNum);
  // };
  // noinspection JSAnnotator
  /**   小数位控制  noinspection JSAnnotator控制 string | number */
  limitDecimals = (values: string | number): string => {
    let reg = '';
    if (this.floatNum > 0) {
      reg = `^(\\d+).(${this.floatPrice})*$`;
    } else {
      reg = '^(\\d+).(\\d\\d\\d\\d\\d\\d)*$';
    }
    if (typeof values === 'string') {
      if (values !== undefined && values.indexOf('.') <= -1) {
        reg = '^(\\d+)*$';
        return !isNaN(Number(values)) ? values.replace(new RegExp(reg), '$1') : '';
      } else {
        return !isNaN(Number(values)) ? values.replace(new RegExp(reg), '$1.$2') : '';
      }
    } else if (typeof values === 'number') {
      if (values !== undefined && String(values).indexOf('.') <= -1) {
        reg = '^(\\d+)*$';
        return !isNaN(values) ? String(values).replace(new RegExp(reg), '$1') : '';
      } else {
        return !isNaN(values) ? String(values).replace(new RegExp(reg), '$1.$2') : '';
      }
    } else {
      return '';
    }
  };

  /**   渲染   */
  render() {
    /*   获取innerinput控件参数   */
    const innerInputProps = this.getInnerInputProps();
    /*   获取innerinput控件   */
    const innerInput = this.getInnerInput(innerInputProps);

    /*   获取outformitem控件参数   */
    const outFormItemProps = this.getOutFormItemProps();

    /*   获取fieldDecorator参数   */
    const fieldDecoratorProps = this.getFieldDecoratorProps();

    /*   通用组件(主表存在getFieldDecorator表单验证,而从表则不需要)   */
    const commonAssembly = (<FormItem {...outFormItemProps}> {!this.props.bTable ? this.getFieldDecorator(this.props.showConfig.sName, fieldDecoratorProps)(innerInput) : innerInput} </FormItem>);
    /*   页面输出   */
    return (
      <div>
        {commonAssembly}
      </div>
    );
  }
}
